import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
import java.util.*;

/**
 * Representa la clase Cubo,
 * la cual se usa para crear
 * los cubos ya sean movibles
 * o fijos.
 * 
 * @author Carlos Bretherton.
 * @version 01 de Mayo del 2012.
 */
public class Cubo extends Personajes
{
    protected int dir;
    protected boolean ban;
    
    /**
     * Constructor de los objetos
     * de la clase Cubo.
     * @param tipo Define el tipo de personaje.
     * @param x Posición en el eje horizontal;
     * @param y Posición en el eje vertical;
     */
    public Cubo(int tipo, int x, int y)
    {
        super( tipo, x, y );
        ban = false;
    }
    
    /**
     * Actua de los objetos de la clase Cubo,
     * llama al método desliza si la variable
     * ban es verdadera, es decir, si se tiene
     * que mover el cubo lo mueve en dirección
     * de acuerdo a la variable dir.
     */
    public void act() 
    {
        super.act();
        if( ban == true )
        {
            this.dezliza();
        }
    }
    
    /**
     * De acuerdo a la variable dir mueve el cubo 
     * mientras no choque ya sea con un enemigo u
     * otro cubo, para esto verifica en el camino
     * si intersecta con un personaje.
     */
    public void dezliza()
    {
        switch(dir)
        {
            case RIGHT: super.mover(RIGHT);
                        if(px == 14 || destruirEnemigo() || intersectaCubo() )
                        {
                            if(px == 14 && !intersectaCubo())
                            {
                                world.Arr[py][px] = 0;
                            }
                            this.destruir();
                        }
                        else
                        {
                            if(tipo == CUBOFIJO)
                            {
                                ban = false;
                                world.Arr[py][px] = CUBOFIJO;
                            }
                        }
                        world.Arr[py][px-1] = 0;
            break;
            case LEFT: super.mover(LEFT);
                       if(px == 0 || destruirEnemigo() || intersectaCubo())
                       {
                           if(px == 0 && !intersectaCubo())
                           {
                               world.Arr[py][px] = 0;
                           }
                           this.destruir();
                       }
                       else
                       {
                           if(tipo == CUBOFIJO)
                           {
                               ban = false;
                               world.Arr[py][px] = CUBOFIJO;
                           }
                       }
                       world.Arr[py][px+1] = 0;
            break;
            case UP: super.mover(UP);
                     if(py == 0 || destruirEnemigo() || intersectaCubo())
                     {
                         if(py == 0 && !intersectaCubo())
                         {
                             world.Arr[py][px] = 0;
                         }
                         this.destruir();
                     }
                     else
                     {
                         if(tipo == CUBOFIJO)
                         {
                             ban = false;
                             world.Arr[py][px] = CUBOFIJO;
                         }
                     }
                     world.Arr[py+1][px] = 0;
            break;
            case DOWN: super.mover(DOWN);
                       if(py == 14 || destruirEnemigo() || intersectaCubo())
                       {
                           if(py == 14 && !intersectaCubo())
                           {
                               world.Arr[py][px] = 0;
                           }
                           this.destruir();
                       }
                       else
                       {
                           if(tipo == CUBOFIJO)
                           {
                               ban = false;
                               world.Arr[py][px] = CUBOFIJO;
                            }
                       }
                       world.Arr[py-1][px] = 0;
            break;
        }
    }   
    
    /**
     * Verifica si intersecta con un objeto
     * enemigo, si intersecta elimina al 
     * enemigo y se elimina el mismo.
     */
    public boolean destruirEnemigo()
    {
        Enemies enemigo = (Enemies)getOneObjectAtOffset(0, 0, Enemies.class);
        if( enemigo != null )
        {
            world.nenemigos--;
            if(enemigo instanceof JackFrost)
            {
                world.puntos+=5;
            }
            if(enemigo instanceof SnowBox)
            {
                world.puntos+=10;
            }
            if(enemigo instanceof SnowBall)
            {
                world.puntos+=15;
            }
            enemigo.destruir();
            r = new Random();
            if(r.nextInt(25) == 7)
            {
                world.addObject(new Life(LIFE,px,py),18 + (px*33), 60 + (py * 33));
            }
            return true;
        }
        return false;
    }
    
    /**
     * Verifica si intersecta con un objeto
     * cubo, se elimina el mismo.
     */
    public boolean intersectaCubo()
    {
        Cubo cubo = (Cubo)getOneObjectAtOffset(0, 0, Cubo.class);
        if( cubo != null )
        {
            r = new Random();
            if(r.nextInt(25) == 7)
            {
                world.addObject(new Life(LIFE,px,py),18 + (px*33), 60 + (py * 33));
            }
            return true;
        }
        return false;
    }
}
